YES 2.178 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule Main
  ((significand :: Float  ->  Float) :: Float  ->  Float)

module Main where
  import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(m,_)→m

is transformed to
m0 (m,_) = m



↳ HASKELL
  ↳ LR
HASKELL
      ↳ BR

mainModule Main
  ((significand :: Float  ->  Float) :: Float  ->  Float)

module Main where
  import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule Main
  ((significand :: Float  ->  Float) :: Float  ->  Float)

module Main where
  import qualified Prelude



Cond Reductions:
The following Function with conditions
power vw 0 = 1.0
power x vx@(y+1) = fromInt x * power x y
power x y = 1.0 / power x (`negate` y)

is transformed to
power vw xw = power4 vw xw
power x vx = power2 x vx
power x y = power0 x y

power0 x y = 1.0 / power x (`negate` y)

power1 True x vx = fromInt x * power x (vx - 1)
power1 wx wy wz = power0 wy wz

power2 x vx = power1 (vx >= 1) x vx
power2 xu xv = power0 xu xv

power3 True vw xw = 1.0
power3 xx xy xz = power2 xy xz

power4 vw xw = power3 (xw == 0) vw xw
power4 yu yv = power2 yu yv

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule Main
  ((significand :: Float  ->  Float) :: Float  ->  Float)

module Main where
  import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
encodeFloat m (`negate` floatDigits x)
where 
m  = m0 vu11
m0 (m,vv) = m
vu11  = decodeFloat x

are unpacked to the following functions on top level
significandM0 yw (m,vv) = m

significandM yw = significandM0 yw (significandVu11 yw)

significandVu11 yw = decodeFloat yw

The bindings of the following Let/Where expression
fromInteger x * power 2 y
where 
power vw xw = power4 vw xw
power x vx = power2 x vx
power x y = power0 x y
power0 x y = 1.0 / power x (`negate` y)
power1 True x vx = fromInt x * power x (vx - 1)
power1 wx wy wz = power0 wy wz
power2 x vx = power1 (vx >= 1) x vx
power2 xu xv = power0 xu xv
power3 True vw xw = 1.0
power3 xx xy xz = power2 xy xz
power4 vw xw = power3 (xw == 0) vw xw
power4 yu yv = power2 yu yv

are unpacked to the following functions on top level
primFloatEncodePower4 vw xw = primFloatEncodePower3 (xw == 0) vw xw
primFloatEncodePower4 yu yv = primFloatEncodePower2 yu yv

primFloatEncodePower1 True x vx = fromInt x * primFloatEncodePower x (vx - 1)
primFloatEncodePower1 wx wy wz = primFloatEncodePower0 wy wz

primFloatEncodePower3 True vw xw = 1.0
primFloatEncodePower3 xx xy xz = primFloatEncodePower2 xy xz

primFloatEncodePower vw xw = primFloatEncodePower4 vw xw
primFloatEncodePower x vx = primFloatEncodePower2 x vx
primFloatEncodePower x y = primFloatEncodePower0 x y

primFloatEncodePower2 x vx = primFloatEncodePower1 (vx >= 1) x vx
primFloatEncodePower2 xu xv = primFloatEncodePower0 xu xv

primFloatEncodePower0 x y = 1.0 / primFloatEncodePower x (`negate` y)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ NumRed

mainModule Main
  ((significand :: Float  ->  Float) :: Float  ->  Float)

module Main where
  import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
HASKELL
                      ↳ Narrow

mainModule Main
  (significand :: Float  ->  Float)

module Main where
  import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yx2800), Succ(yx271000)) → new_primPlusNat(yx2800, yx271000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yx26000), yx27100) → new_primMulNat(yx26000, yx27100)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_primFloatEncodePower3(Succ(yx70)) → new_primFloatEncodePower3(yx70)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: